home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Portable Patmos 1.1 / patmos-src / src / socket.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-02-01  |  40.7 KB  |  1,702 lines  |  [TEXT/R*ch]
  1. /*
  2.  * BSD-style socket emulation library for the Mac
  3.  * Original author: Tom Milligan
  4.  * Current author: Charlie Reiman - creiman@ncsa.uiuc.edu
  5.  *
  6.  * This source file is placed in the public domian.
  7.  * Any resemblance to NCSA Telnet, living or dead, is purely coincidental.
  8.  *
  9.  *      National Center for Supercomputing Applications
  10.  *      152 Computing Applications Building
  11.  *      605 E. Springfield Ave.
  12.  *      Champaign, IL  61820
  13.  */
  14.  
  15. /*
  16.  *
  17.  *    The following calls are implemented
  18.  *
  19.  *        socket
  20.  *        bind
  21.  *        listen
  22.  *        accept
  23.  *        connect
  24.  *        read
  25.  *        recv
  26.  *        recvfrom
  27.  *        write
  28.  *        writev
  29.  *        send
  30.  *        sendto
  31.  *        select
  32.  *        close
  33.  *        getdtablesize
  34.  *        getsockname
  35.  *        getpeername
  36.  *        shutdown
  37.  *        fcntl(F_DUPFD)
  38.  *        fcntl(F_GETFL)
  39.  *        fcntl(F_SETFL,FNDELAY)
  40.  *        dup
  41.  *        dup2
  42.  *        ioctl(FIONBIO)
  43.  *        ioctl(FIONREAD)
  44.  *
  45.  *    Non-blocking I/O is supported. All calls which would block return
  46.  *    immediately with an 'error' indicating so. Select() may be used to
  47.  *    determine when an operation can be performed.
  48.  *
  49.  *    Ioctl(FIONBIO) or fcntl(F_SETFL,FNDELAY)  can be used to toggle or set
  50.  *  the blocking status of a socket.
  51.  *
  52.  *    In a blocking situation, accept() and read() return EWOULDBLOCK and 
  53.  *    refuse to do anything. Select() for read() to learn when a incoming 
  54.  *    connection is available. 
  55.  *
  56.  *    Connect() and write() (which shouldn't take too long anyway) start 
  57.  *    the operation and return EINPROGRESS. Select for write() to learn
  58.  *    when connect() has completed. Write() on a socket which is still
  59.  *    'inprogress' return EALREADY.
  60.  *
  61.  *
  62.  *    Socket operations are single threaded and half-duplex. Fixing this is
  63.  *    left as an execise for the reader. Shouldn't be a terrible problem
  64.  *    anyway. Read() never blocks and write() only blocks for long if there
  65.  *    is a problem.
  66.  *
  67.  *    Calls which find the socket busy will return EALREADY. These are
  68.  *    read() or write() with a connect() or write() in progress.
  69.  *
  70.  *
  71.  *    Socket options are not supported. Hence no setsockopt() and getsockopt() 
  72.  *    calls.
  73.  *
  74.  *
  75.  *  CR: I attempted to support OOB data for send and recv, but not promises are
  76.  *  made as I didn't have any immediate tests for them.
  77.  *
  78.  *
  79.  *    Readv() is not implemented.
  80.  *
  81.  *
  82.  *    All calls which encounter an error will set the global variable errno
  83.  *    to indicate the problem. Some common values for errno are...
  84.  *
  85.  *        EBADF        the socket parameter is not a valid socket descriptor.
  86.  *        
  87.  *        EFAULT       a pointer parameters is rubbish.
  88.  *        
  89.  *        EINVAL       a non-pointer parameters is rubbish.
  90.  *
  91.  *        ENOTCONN     the socket should be in a connected state for this 
  92.  *                   operation, but isn't.
  93.  *
  94.  *        EISCONN      the socket is already connected.
  95.  *
  96.  * ----------------- non-blocking I/O
  97.  *
  98.  *        EWOULDBLOCK  accept() or one of the read() calls would block. 
  99.  *
  100.  *        EINPROGRESS  connect() or one of the write() operations has been 
  101.  *                   started.
  102.  *
  103.  * ----------------- SINGLE THREAD
  104.  *
  105.  *        EALREADY     an operation is already in progress on the socket.
  106.  *
  107.  * ----------------
  108.  *
  109.  *        EBUG           an internal error occured.
  110.  */
  111.  
  112. #ifdef USEDUMP
  113. # pragma load "socket.dump"
  114.  
  115. #else
  116. # include <Events.h>
  117. # include <Types.h>
  118. # include <Stdio.h>
  119. # include <string.h>
  120. # include <s_types.h>
  121. # include <neti_in.h>
  122. # include <neterrno.h>
  123. # include <s_file.h>
  124. # include <s_ioctl.h>
  125. # include <s_socket.h>
  126. # include <s_time.h>
  127. # include <s_uio.h>
  128.  
  129. # include "sock_str.h"
  130. # include "sock_int.h"
  131.  
  132. #endif
  133.  
  134. #include "sock_ext.h"
  135.  
  136.  
  137. /*
  138.  *   GET YOUR GLOBALS HERE!
  139.  */
  140.  
  141. int defaultSpin(spin_msg msg,long param);
  142. SocketPtr sockets = NULL;            /* The socket table. */
  143. AllPb *pbList = NULL;                /* The pb array */
  144. short pbLast = 0;                    /* last pb used */
  145. StreamHashEntPtr streams = NULL;    /* The streams hash table */
  146. SpinFn spinroutine = (SpinFn) defaultSpin;    /* The spin routine. */ 
  147.  
  148. /*
  149.  *    s_socket(domain, type, protocol)
  150.  *
  151.  *        socket creates a MacTCP socket and returns a descriptor.
  152.  *                 
  153.  *        Domain must be AF_INET
  154.  *         
  155.  *        Type may be SOCK_STREAM to create a TCP socket or 
  156.  *        SOCK_DGRAM to create a UDP socket.
  157.  *                 
  158.  *        Protocol is ignored. (isn't it always?)
  159.  *                 
  160.  *        TCP sockets provide sequenced, reliable, two-way connection
  161.  *        based byte streams.
  162.  *
  163.  *        A TCP socket must be in a connected
  164.  *        state before any data may be sent or received on it. A 
  165.  *        connection to another socket is created with a connect() call
  166.  *        or the listen() and accept() calls.
  167.  *        Once connected, data may be transferred using read() and
  168.  *        write() calls or some variant of the send() and recv()
  169.  *        calls. When a session has been completed a close() may  be
  170.  *        performed.
  171.  *
  172.  *        
  173.  *        A UDP socket supports the exchange of datagrams (connectionless, 
  174.  *        unreliable messages of a fixed maximum length) with  
  175.  *        correspondents named in send() calls. Datagrams are
  176.  *        generally received with recv(), which returns the next
  177.  *        datagram with its return address.
  178.  *
  179.  *        An fcntl() or ioctl() call can be used to enable non-blocking I/O.
  180.  *
  181.  *        The return value is a descriptor referencing the socket or -1
  182.  *        if an error occurs, in which case global variable errno is
  183.  *        set to one of:
  184.  *
  185.  *            ENOMEM                Failed to allocate memory for the socket
  186.  *                              data structures.
  187.  *        
  188.  *            EAFNOSUPPORT         Domain wasn't AF_INET.
  189.  *
  190.  *            ESOCKTNOSUPPORT     Type wasn't SOCK_STREAM or SOCK_DGRAM.
  191.  *
  192.  *            EMFILE              The socket descriptor table is full.
  193.  */
  194. int s_socket(
  195.     Int4 domain,
  196.     Int4 type,
  197.     short protocol)
  198. {
  199.     SocketPtr sp;
  200.     int s;
  201.  
  202. #if    SOCK_DEBUG >= 3
  203.     dprintf("s_socket:\n");
  204. #endif
  205.  
  206.     sock_init();
  207.     
  208.     /*
  209.      * Support only Internet family
  210.      */
  211.     if ((domain != AF_INET) && (domain != AF_UNIX))
  212.         return(sock_err(EAFNOSUPPORT));
  213.         
  214.     switch(type) 
  215.     {
  216.         case SOCK_DGRAM:
  217.             protocol = IPPROTO_UDP;
  218.             break;
  219.         case SOCK_STREAM:
  220.             protocol = IPPROTO_TCP;
  221.             break;
  222.         default:
  223.             return(sock_err(ESOCKTNOSUPPORT));
  224.     }
  225.         
  226.     /*
  227.      *    Create a socket table entry 
  228.      */
  229.     s = sock_free_fd(0);        /* Get next free file descriptor */
  230.     if (s == -1)
  231.         return(sock_err(EMFILE));
  232.     sp = sockets+s;
  233.     sp->fd = s;
  234.     sp->protocol = protocol;
  235.     bzero(&sp->sa, sizeof(struct sockaddr_in));
  236.     bzero(&sp->peer, sizeof(struct sockaddr_in));
  237.     sp->sa.sin_family        = AF_INET;
  238.     sp->sa.sin_len            = sizeof(struct sockaddr_in);
  239.     sp->status                = SOCK_STATUS_USED;
  240.     sp->nonblocking            = false;
  241.  
  242.  
  243.     /* Create a new stream on the socket. */
  244.     switch(sp->protocol) 
  245.     {
  246.         case IPPROTO_UDP:
  247.             /* udp streams are not created until the last minute */
  248.             /* because we dont know if the caller wants to assign */
  249.             /* a special port number yet (via bind) and mactcp */
  250.             /* assigns udp port numbers at stream creation */
  251.             sp->sstate = SOCK_STATE_NO_STREAM;
  252.             break;
  253.  
  254.         case IPPROTO_TCP:
  255.             /* the tcp stream is created now because tcp port numbers */
  256.             /* are assigned during active/passiveOpen which is done */
  257.             /* during listen or connect */
  258.             sp->sstate = SOCK_STATE_UNCONNECTED;
  259.             if (sock_tcp_new_stream(sp) < 0)
  260.                 return(-1); /* sock_err already called */
  261.     }
  262.  
  263.     return(s);
  264. }
  265.  
  266.  
  267. /*
  268.  *    s_bind(s, name, namelen)
  269.  *
  270.  *        bind requests that the name (ip address and port) pointed to by 
  271.  *        name be assigned to the socket s.
  272.  *        
  273.  *        The return value is 0 on success or -1 if an error occurs,
  274.  *        in which case global variable errno is set to one of:
  275.  *
  276.  *        EAFNOSUPPORT        The address family in name is not AF_INET.
  277.  *        
  278.  *        EINVAL              The socket is already bound to an address.
  279.  *        
  280.  *        EADDRNOTAVAIL       The specified address is  not  available
  281.  *                             from the local machine. ie. the address
  282.  *                            portion of name was not this machine's address.
  283.  *
  284.  *        MacTCP does not separate name binding and connection establishment.
  285.  *        Therefore the port number is not verified, just stored for later use.
  286.  *
  287.  *        If a specific local port is not required, bind is optional in this
  288.  *        implementation.
  289.  */    
  290.  
  291. int s_bind( 
  292.     Int4 s, 
  293.     struct sockaddr *sa_name,
  294.     Int4 namelen)
  295. {
  296.     SocketPtr sp;
  297.     struct sockaddr_in *name=(struct sockaddr_in *)sa_name;
  298.  
  299.     struct timeval ktime;
  300.     struct timezone kzone;
  301.     gettimeofday(&ktime, &kzone);
  302.     
  303. #if    SOCK_DEBUG >= 3
  304.     dprintf("s_bind: bind %d to %08x/%d\n",
  305.         s, name->sin_addr.s_addr, name->sin_port);
  306. #endif
  307.  
  308.     if (! sock_good_fd(s))
  309.         return(sock_err(EBADF));
  310.     sp = sockets+s;
  311.         
  312.     if (namelen < sizeof(struct sockaddr_in))
  313.         return(sock_err(EINVAL));
  314.  
  315.     if (!goodptr(name)) 
  316.         return(sock_err(EFAULT));
  317.  
  318.     if ((name->sin_family != AF_INET) && (name->sin_family != AF_UNIX))
  319.         return(sock_err(EAFNOSUPPORT));
  320.  
  321.     if (sp->sa.sin_port != 0) /* already bound */
  322.         return(sock_err(EINVAL));
  323.  
  324.     /*
  325.      *    If client passed a local IP address, assure it is the right one
  326.      */
  327.     if (name->sin_addr.s_addr != 0) 
  328.     {
  329.         if (name->sin_addr.s_addr != xIPAddr())
  330.             return(sock_err(EADDRNOTAVAIL));
  331.     }
  332.  
  333.     /*
  334.      *    NOTE: can't check a TCP port for EADDRINUSE
  335.      *    just save the address and port away for connect or listen or...
  336.      */
  337.     sp->sa.sin_addr.s_addr = name->sin_addr.s_addr;
  338.     if (!name->sin_port) name->sin_port = (ktime.tv_sec&8191)+4000;
  339.     sp->sa.sin_port = name->sin_port;
  340.     return(0);
  341. }
  342.  
  343. /*
  344.  *    s_connect - initiate a connection on a MacTCP socket
  345.  *
  346.  *        If the parameter s is a UDP socket,
  347.  *        then  this  call specifies the address to  which  datagrams
  348.  *        are  to  be  sent, and the only address from which datagrams
  349.  *        are to be received.  
  350.  *             
  351.  *        If it is a TCP socket, then this call attempts to make a 
  352.  *        connection to another socket. The other socket is specified 
  353.  *        by an internet address and port.
  354.  *             
  355.  *        TCP sockets may successfully connect() only once;
  356.  *             
  357.  *        UDP sockets may use connect() multiple times to change
  358.  *        their association. UDP sockets may dissolve the association
  359.  *        by connecting to an invalid address, such as a null
  360.  *        address.
  361.  *        
  362.  *        If the connection or binding succeeds, then 0 is returned.
  363.  *        Otherwise a -1 is returned, and a more specific error code
  364.  *        is stored in errno.
  365.  *        
  366.  *        EAFNOSUPPORT        The address family in addr is not AF_INET.
  367.  *        
  368.  *        EHOSTUNREACH        The TCP connection came up half-way and 
  369.  *                          then failed.
  370.  *             
  371.  *    -------------- some day instead of EHOSTUNREACH -----------------
  372.  *        
  373.  *        EADDRNOTAVAIL       The specified address is not available
  374.  *                            on the remote machine.
  375.  *        
  376.  *        ETIMEDOUT           Connection establishment timed out
  377.  *                            without establishing a connection.
  378.  *        
  379.  *        ECONNREFUSED        The attempt to  connect  was  forcefully
  380.  *                            rejected.
  381.  *        
  382.  *        ENETUNREACH         The network is not reachable from here.
  383.  *        
  384.  *        EHOSTUNREACH        The host is not reachable from here.
  385.  *        
  386.  *        EADDRINUSE          The address is already in use.
  387.  */
  388. int s_connect(
  389.     Int4 s,
  390.     struct sockaddr *sa_addr,
  391.     Int4 addrlen)
  392. {
  393.     SocketPtr sp;
  394.     struct sockaddr_in *addr=(struct sockaddr_in *)sa_addr;
  395.     
  396. #if SOCK_DEBUG >= 2
  397.     dprintf("s_connect: connect %d to %08x/%d\n",
  398.         s, addr->sin_addr.s_addr, addr->sin_port);
  399. #endif
  400.     if (! sock_good_fd(s))
  401.         return(sock_err(EBADF));
  402.         
  403.     if (addrlen != sizeof(struct sockaddr_in))
  404.         return(sock_err(EINVAL));
  405.  
  406.     if (! goodptr(addr))
  407.         return(sock_err(EFAULT));
  408.  
  409.     if (addr->sin_family != AF_INET)
  410.         return(sock_err(EAFNOSUPPORT));
  411.  
  412.     sp = sockets+s;
  413.     switch(sp->protocol) 
  414.     {
  415.         case IPPROTO_UDP:
  416.             return(sock_udp_connect(sp,addr));
  417.  
  418.         case IPPROTO_TCP:
  419.             return(sock_tcp_connect(sp,addr));
  420.     }
  421. }
  422.  
  423. /*
  424.  *    s_listen()
  425.  *
  426.  *        To accept connections, a socket is first created  with
  427.  *        socket(), a backlog for incoming connections is specified
  428.  *        with listen() and then the  connections  are  accepted  with
  429.  *        accept(). The listen() call applies only to TCP sockets.
  430.  *        
  431.  *        The qlen parameter is supposed to define the maximum length
  432.  *        the queue of pending connections may grow to. It is ignored.
  433.  *        
  434.  *        A 0 return value indicates success; -1 indicates an error.
  435.  *        
  436.  *        EOPNOTSUPP          s is not a TCP socket.
  437.  */
  438. int s_listen(
  439.     Int4 s,
  440.     Int4 qlen)
  441. {
  442. #pragma unused(qlen)
  443.     SocketPtr sp;
  444.     
  445. #if SOCK_DEBUG >= 2
  446.     dprintf("listen: listen %d\n", s);
  447. #endif
  448.     if (! sock_good_fd(s))
  449.         return(sock_err(EBADF));
  450.         
  451.     sp = sockets+s;    
  452.     switch(sp->protocol) 
  453.     {
  454.         case IPPROTO_UDP:
  455.             return(sock_err(EOPNOTSUPP));
  456.         
  457.         case IPPROTO_TCP:
  458.             return(sock_tcp_listen(sp));
  459.     }
  460. }
  461.  
  462. /*
  463.  *    s_accept(s, addr, addrlen)
  464.  *
  465.  *        s is a socket that has been created with socket,  bind, listen.
  466.  *        
  467.  *        Accept  extracts the  first  connection  on the queue of pending 
  468.  *        connections, creates a new socket with the same properties of s 
  469.  *        and allocates  a  new  file  descriptor,  ns, for the socket.
  470.  *        
  471.  *        If no pending connections are present on the queue, and the socket
  472.  *        is not marked as non-blocking, accept blocks the caller until
  473.  *        a connection is present. 
  474.  *        
  475.  *        If the socket is marked non-blocking  and  no pending connections 
  476.  *        are present on the queue, accept returns an error EWOULDBLOCK.
  477.  *        
  478.  *        The accepted socket, ns, is used to read and write data to and
  479.  *        from the socket which connected to this one; it is not  used
  480.  *        to  accept  more connections.  The original socket s remains
  481.  *        open for accepting further connections.
  482.  *        
  483.  *        The argument addr is a result parameter that  is  filled  in
  484.  *        with  the  address of the connecting socket. The addrlen is 
  485.  *        a value-result  parameter; it should initially contain the
  486.  *        amount of space pointed to by addr; on return it will contain 
  487.  *        the actual length (in bytes) of the address returned.
  488.  *        
  489.  *        This call is used with TCP sockets only.
  490.  *        
  491.  *        It is possible to select a socket  for  the  purposes  of
  492.  *        doing an accept by selecting it for read.
  493.  *
  494.  *        Translation: To check and see if there is a connection pending,
  495.  *        call s_select and check for pending reads.
  496.  *        
  497.  *        The call returns -1 on error.  If it succeeds, it returns  a
  498.  *        non-negative  integer  that is a descriptor for the accepted
  499.  *        socket.
  500.  *        
  501.  *        EOPNOTSUPP          s is not a TCP socket.
  502.  *        
  503.  *        EMFILE              The socket descriptor table is full.
  504.  */
  505. int s_accept(
  506.     Int4 s,
  507.     struct sockaddr *sa_addr,
  508.     Int4 *addrlen)
  509. {
  510.     SocketPtr sp;
  511.     struct sockaddr_in *addr=(struct sockaddr_in *)sa_addr;
  512.  
  513. #if SOCK_DEBUG >= 2
  514.     dprintf("s_accept: %d\n", s);
  515. #endif
  516.     if (! sock_good_fd(s))
  517.         return(sock_err(EBADF));
  518.         
  519.     if (!goodptr(addr) || !goodptr(addrlen)) 
  520.         return(sock_err(EFAULT));
  521.  
  522.     if (*addrlen < 0) 
  523.         return(sock_err(EINVAL));
  524.  
  525.     if (sock_free_fd(0) == -1)
  526.         return(sock_err(EMFILE));
  527.  
  528.     sp = sockets+s;
  529.     switch(sp->protocol) 
  530.     {
  531.         case IPPROTO_UDP:
  532.             return(sock_err(EOPNOTSUPP));
  533.         case IPPROTO_TCP:
  534.             return(sock_tcp_accept(sp,addr,addrlen));
  535.     }
  536. }
  537.  
  538. /*
  539.  * s_accept_once
  540.  *
  541.  * A mac specific routine, designed to compenstate for a bug
  542.  * in MacTCP. If you close a passive, unconnected stream,
  543.  * MacTCP will generate an error. s_accept always creates
  544.  * a new listening (passive open) stream that will eventually
  545.  * need to be closed. s_accept_once does not create a new
  546.  * listening socket. It will return the same socket originally
  547.  * passed to it, and NO more connections will be accepted
  548.  * on the old listening port.
  549.  *
  550.  * Other than that, it is identical to s_accept.
  551.  */
  552. int s_accept_once(
  553.     Int4 s,
  554.     struct sockaddr *sa_addr,
  555.     Int4 *addrlen)
  556. {
  557.     SocketPtr sp;
  558.     struct sockaddr_in *addr=(struct sockaddr_in *)sa_addr;
  559.  
  560. #if SOCK_DEBUG >= 2
  561.     dprintf("s_accept: %d\n", s);
  562. #endif
  563.     if (! sock_good_fd(s))
  564.         return(sock_err(EBADF));
  565.         
  566.     if (!goodptr(addr) || !goodptr(addrlen)) 
  567.         return(sock_err(EFAULT));
  568.  
  569.     if (*addrlen < 0) 
  570.         return(sock_err(EINVAL));
  571.  
  572.     if (sock_free_fd(0) == -1)
  573.         return(sock_err(EMFILE));
  574.  
  575.     sp = sockets+s;
  576.     switch(sp->protocol) 
  577.     {
  578.         case IPPROTO_UDP:
  579.             return(sock_err(EOPNOTSUPP));
  580.         case IPPROTO_TCP:
  581.             {
  582.             int        returnCode;
  583.             
  584.             returnCode=sock_tcp_accept_once(sp,addr,addrlen);
  585.             return (returnCode ? returnCode : s );
  586.             }
  587.     }
  588. }
  589.  
  590. /*
  591.  *    s_close(s)
  592.  *
  593.  *        The close call destroys the socket s. If this is the last reference 
  594.  *        to the underlying MacTCP stream, then the stream will be released.
  595.  *    
  596.  *        A 0 return value indicates success; -1 indicates an error.
  597.  *
  598.  *        NOTE: if non-blocking I/O is enabled EWOULDBLOCK will be returned
  599.  *            if there are TCP writes in progress. (UDP writes are
  600.  *            performed synchronously.)
  601.  *
  602.  *              All reads are terminated and unread data is lost.
  603.  */
  604. int s_close(
  605.     Int4 s)
  606. {
  607.     int t;
  608.     SocketPtr sp;
  609.     int status;
  610.     
  611. #if SOCK_DEBUG >= 2
  612.     dprintf("s_close: %d\n", s);
  613. #endif
  614.     if (! sock_good_fd(s))
  615.         return(sock_err(EBADF));
  616.         
  617.     sp = sockets+s;
  618.  
  619.     /*
  620.      *    Look for duplicates of the socket.  Only close down the connection
  621.      *    if there are no duplicates(i.e. socket not dup'd).
  622.      */
  623.      for (t = 0; t < NUM_SOCKETS; t++) 
  624.      {
  625.          if (t == s)
  626.             continue;
  627.          if (!(sockets[t].status & SOCK_STATUS_USED))
  628.             continue;
  629.         else if (sockets[t].protocol == sp->protocol && sockets[t].stream == sp->stream )
  630.         {    /* found a duplicate */
  631. #if SOCK_DEBUG >= 3
  632.             dprintf("s_close: found a dup at %d(%d, don't close stream\n",
  633.                 t, sockets[t].protocol);
  634. #endif
  635.             sock_clear_fd(s);
  636.             return(0);
  637.         }
  638.     }
  639.  
  640.     /*
  641.      *    No duplicates, close the stream. 
  642.      */
  643.     switch(sp->protocol) 
  644.     {
  645.         case IPPROTO_UDP:
  646.             status = sock_udp_close(sp);
  647.             break;
  648.             
  649.         case IPPROTO_TCP:
  650.             status = sock_tcp_close(sp);
  651.             break;
  652.     }
  653.     if (status != EWOULDBLOCK)
  654.         sock_clear_fd(s);
  655.     return(status);
  656. }
  657.  
  658.  
  659. /*
  660.  *    s_read(s, buffer, buflen)
  661.  *
  662.  *    s_recv(s, buffer, buflen, flags)
  663.  *    
  664.  *    s_recvfrom(s, buffer, buflen, flags, from, fromlen)
  665.  *    
  666.  *        read() attempts to read nbytes of data from the socket s.  
  667.  *        
  668.  *        recv() and recvfrom() attempt to receive a message (ie a datagram) 
  669.  *        on the socket s. 
  670.  *
  671.  *        from returns the address of the socket which sent the message.
  672.  *        fromlen is the usual value-result length parameter. 
  673.  *        
  674.  *        Typically, read() is used with a TCP stream and recv() with
  675.  *        UDP where the idea of a message makes more sense. But in fact,
  676.  *        read() and recv() are equivalent.
  677.  *        
  678.  *        For UDP...
  679.  *            If a message (ie. datagram) is too long to fit in the supplied 
  680.  *            buffer, excess bytes will be discarded..
  681.  *
  682.  *            If no messages are available at the socket, the receive call
  683.  *            waits for a message to arrive, unless the socket is non-
  684.  *            blocking in which case -1 is returned with errno set to 
  685.  *            EWOULDBLOCK.
  686.  *
  687.  *        For TCP...
  688.  *            Regardless of non-blocking status, if less data is available
  689.  *            than has been requested, only that much data is returned.
  690.  *
  691.  *            If the socket is marked for non-blocking I/O, and the socket 
  692.  *            is empty, the operation will fail with the error EWOULDBLOCK.
  693.  *            Otherwise, the operation will block until data is available 
  694.  *            or an error occurs.
  695.  *
  696.  *            A return value of zero indicates that the stream has been
  697.  *            closed and all data has already been read. ie. end-of-file.
  698.  *        
  699.  *        Flags is ignored.
  700.  *        
  701.  *        If successful, the number of bytes actually received is
  702.  *        returned. Otherwise, a -1 is returned and the global variable
  703.  *        errno is set to indicate the error. 
  704.  *        
  705.  *        ESHUTDOWN    The socket has been shutdown for receive operations.
  706.  */
  707. int s_recvfrom(
  708.     Int4 s,
  709.     char *buffer,
  710.     Int4 buflen,
  711.     Int4 flags,
  712.     struct sockaddr *sa_from,
  713.     Int4 *fromlen);
  714.  
  715. int s_read(
  716.     Int4 s,
  717.     char *buffer,
  718.     Int4 buflen)
  719. {
  720.     int fromlen = 0;
  721.     return(s_recvfrom(s, buffer, buflen, 0, NULL, (void *)&fromlen));
  722. }
  723.  
  724. int s_recv(
  725.     Int4 s,
  726.     char *buffer,
  727.     Int4 buflen,
  728.     Int4 flags)
  729. {
  730.     int fromlen = 0;
  731.     return(s_recvfrom(s, buffer, buflen, flags, NULL, (void *)&fromlen));
  732. }
  733.  
  734. int s_recvfrom(
  735.     Int4 s,
  736.     char *buffer,
  737.     Int4 buflen,
  738.     Int4 flags,
  739.     struct sockaddr *sa_from,
  740.     Int4 *fromlen)
  741. {
  742.     SocketPtr sp;
  743.     struct sockaddr_in *from=(struct sockaddr_in *)sa_from;
  744.  
  745. #if SOCK_DEBUG >= 3
  746.     dprintf ("s_recvfrom: %d\n", s);
  747. #endif
  748.     if (s < 0 || s >= NUM_SOCKETS)
  749.         return (sock_err (EBADF));
  750.         
  751.     sp = sockets+s;
  752.     if (! is_used (sp))
  753.         return (sock_err (EBADF));
  754.         
  755.     if (!goodptr(buffer))
  756.         return (sock_err (EFAULT));
  757.         
  758.     if (buflen <= 0)
  759.         return(sock_err(EINVAL));
  760.         
  761.     if (! (from == NULL || goodptr(from)) )
  762.         return(sock_err(EFAULT));
  763.         
  764.     if (! (fromlen == NULL || goodptr(fromlen)) )
  765.         return(sock_err(EFAULT));
  766.     else
  767.         if ( *fromlen < 0 )
  768.             return(sock_err(EINVAL));
  769.  
  770.     if (sock_noread(sp))
  771.         return(sock_err(ESHUTDOWN));
  772.  
  773.     switch(sp->protocol) 
  774.     {
  775.         case IPPROTO_UDP:
  776.             return(sock_udp_recv(sp, buffer, buflen, flags, from, (int *)fromlen));
  777.  
  778.         case IPPROTO_TCP:
  779.             return(sock_tcp_recv(sp, buffer, buflen, flags));
  780.     }
  781. }
  782.  
  783.  
  784. /*
  785.  *    s_write(s, buffer, buflen)
  786.  *
  787.  *    s_writev(s, iov, iovcnt)
  788.  *
  789.  *    s_send(s, buffer, buflen, flags)
  790.  *
  791.  *    s_sendto(s, buffer, buflen, flags, to, tolen)
  792.  *
  793.  *        write() attempts to write nbytes of data to the socket s from
  794.  *        the buffer pointed to by buffer.
  795.  *        
  796.  *        writev() gathers the output data from the buffers specified 
  797.  *        by the members of the iov array. Each iovec entry specifies 
  798.  *        the base address and length of an area in memory from which 
  799.  *        data should be written.
  800.  *        
  801.  *        send() and sendto() are used to transmit a message to another 
  802.  *        socket on the socket s.
  803.  *
  804.  *        Typically, write() is used with a TCP stream and send() with
  805.  *        UDP where the idea of a message makes more sense. But in fact,
  806.  *        write() and send() are equivalent.
  807.  *        
  808.  *        For UDP...
  809.  *
  810.  *          Write() and send() operations are completed as soon as the
  811.  *          data is placed on the transmission queue.???????
  812.  *
  813.  *            The address of the target is given by to.
  814.  *
  815.  *            The message must be short enough to fit into one datagram.
  816.  *        
  817.  *            Buffer space must be available to hold the message to be 
  818.  *            transmitted, regardless of its non-blocking I/O state.
  819.  *        
  820.  *        For TCP...
  821.  *            Write() and send() operations are not considered complete
  822.  *            until all data has been sent and acknowledged.
  823.  *
  824.  *            If a socket is marked for non-blocking I/O, the operation
  825.  *            will return an 'error' of EINPROGRESS.
  826.  *        
  827.  *            If the socket is not marked for non-blocking I/O, the write will
  828.  *            block until space becomes available.
  829.  *        
  830.  *        write() and send() may be used only when the socket is in a connected
  831.  *        state, sendto() may be used at any time.
  832.  *
  833.  *        Flags is ignored.
  834.  *        
  835.  *        These calls return the number of bytes sent, or -1 if an error 
  836.  *        occurred.
  837.  *        
  838.  *        EINVAL           The sum of the iov_len values in the iov array was
  839.  *                         greater than 65535 (TCP) or 65507 (UDP) or there
  840.  *                       were too many entries in the array (16 for TCP or
  841.  *                       6 for UDP).
  842.  *
  843.  *        ESHUTDOWN        The socket has been shutdown for send operations.
  844.  *        
  845.  *        EMSGSIZE         The message is too big to send in one datagram. (UDP)
  846.  *
  847.  *        ENOBUFS          The transmit queue is full. (UDP)
  848.  */
  849.  
  850. int s_really_send(
  851.     Int4 s,
  852.     char *buffer,
  853.     Int4 count,
  854.     Int4 flags,
  855.     struct sockaddr_in *to);
  856.  
  857. int s_write(
  858.     Int4 s,
  859.     char *buffer,
  860.     Int4 buflen)
  861. {
  862.     return(s_really_send(s, buffer, buflen, 0, NULL));
  863. } 
  864.  
  865. int s_writev(
  866.     Int4 s,
  867.     struct iovec *iov,
  868.     Int4 count)
  869. {    
  870.     int        result,tally=0;
  871.     
  872.     while (count--)
  873.         {
  874.         if ( !goodptr( iov ) )
  875.             return sock_err(EFAULT);
  876.         result= s_really_send(s, (char *)(iov->iov_base),
  877.                 (int)(iov->iov_len), 0, NULL);
  878.         if (result < 0)
  879.             return sock_err(result);
  880.         iov++;
  881.         tally+=result;
  882.         }
  883.     return tally;
  884. } 
  885.  
  886. int s_send(
  887.     Int4 s,
  888.     char *buffer,
  889.     Int4 buflen,
  890.     Int4 flags)
  891. {
  892.     return(s_really_send(s, buffer, buflen, flags, NULL));
  893. } 
  894.  
  895. int s_sendto (
  896.     Int4 s,
  897.     char *buffer,
  898.     Int4 buflen,
  899.     Int4 flags,
  900.     struct sockaddr *sa_to,
  901.     Int4 tolen)
  902. {
  903.     SocketPtr sp;
  904.     struct sockaddr_in *to=(struct sockaddr_in *)sa_to;
  905.  
  906.     if (s < 0 || s >= NUM_SOCKETS)
  907.         return (sock_err (EBADF));
  908.         
  909.     sp = sockets+s;
  910.     
  911.     if (! is_used (sp))
  912.         return (sock_err (EBADF));
  913.         
  914.     if (!goodptr(buffer))
  915.         return (sock_err (EFAULT));
  916.         
  917.     if (buflen <= 0)
  918.         return(sock_err(EINVAL));
  919.         
  920.     if (to != NULL && !goodptr(to))
  921.         return(sock_err(EFAULT));
  922.         
  923.     if (to != NULL && tolen < sizeof(struct sockaddr_in))
  924.         return(sock_err(EINVAL));
  925.  
  926.     return(s_really_send(s, buffer, buflen, flags, to));
  927. }
  928.  
  929. int s_sendmsg(Int4 s,struct msghdr *msg,Int4 flags) {
  930.     SocketPtr sp;
  931.     struct iovec *iov=NULL;
  932.     int tally=0,result,count;
  933.  
  934.     if (s < 0 || s >= NUM_SOCKETS)
  935.         return (sock_err (EBADF));
  936.         
  937.     sp = sockets+s;
  938.     
  939.     if (! is_used (sp))
  940.         return (sock_err (EBADF));
  941.     if (!goodptr(msg))
  942.         return (sock_err (EFAULT));
  943.     if ( msg->msg_name != NULL && !goodptr(msg->msg_name) ) 
  944.         return (sock_err (EFAULT));
  945.     if ( msg->msg_name != NULL && msg->msg_namelen < sizeof (struct sockaddr_in))
  946.         return (sock_err (EFAULT));
  947.     
  948.     count = msg->msg_iovlen;
  949.     iov = msg->msg_iov;
  950.     while ( count -- ) {
  951.         if ( !goodptr( iov ) )
  952.             return sock_err(EFAULT);
  953.         result= s_really_send(s, (char *)(iov->iov_base),
  954.                 (int)(iov->iov_len), flags,(struct sockaddr_in *)msg->msg_name);
  955.         if (result < 0)
  956.             return (sock_err(result));
  957.         iov++;
  958.         tally+=result;
  959.         }
  960.     return tally;
  961.     }
  962.  
  963. int s_really_send(
  964.     Int4 s,
  965.     char *buffer,
  966.     Int4 count,
  967.     Int4 flags,
  968.     struct sockaddr_in *to)
  969.     
  970.     {
  971.     SocketPtr    sp;
  972.     int            tally=0;
  973.  
  974. #if SOCK_DEBUG >= 2
  975.     dprintf("s_really_send: %d  %d bytes", s, count);
  976.     if (to != NULL)
  977.         dprintf(" to %08x/%d",to->sin_addr.s_addr,to->sin_port);
  978.     dprintf("\n");
  979. #endif
  980.     if (! sock_good_fd(s))
  981.         return(sock_err(EBADF));
  982.     sp = sockets+s;
  983.  
  984. #if SOCK_DEBUG >= 2
  985.     dprintf("state %d\n",sp->sstate);
  986.     dprintf("peer %08x/%d\n",sp->peer.sin_addr.s_addr,sp->peer.sin_port);
  987. #endif
  988.     
  989.     if (sock_nowrite(sp))
  990.         return(sock_err(ESHUTDOWN));
  991.  
  992.     switch(sp->protocol) 
  993.         {
  994.         case IPPROTO_UDP:
  995.             if (to == NULL && sp->sstate != SOCK_STATE_CONNECTED) 
  996.                 return(sock_err(ENOTCONN));
  997.             return(sock_udp_send(sp, to, buffer, count, flags));
  998.             break;
  999.             
  1000.         case IPPROTO_TCP:
  1001.             if (to != NULL) /* sendto */
  1002.                 return(sock_err(EOPNOTSUPP));
  1003.             if (sp->sstate != SOCK_STATE_CONNECTED) 
  1004.                 return(sock_err(ENOTCONN));
  1005.             return ( sock_tcp_send(sp, buffer, count,0 ));
  1006.             break;
  1007.         }
  1008.     }
  1009.  
  1010.  
  1011. /*
  1012.  *    s_select(width, readfds, writefds, exceptfds, timeout)
  1013.  *
  1014.  *        select() examines the I/O descriptor  sets  whose  addresses
  1015.  *        are  passed  in  readfds,  writefds, and exceptfds to see if
  1016.  *        some of their descriptors are ready for reading,  ready  for
  1017.  *        writing, or have an exceptional condition pending.  width is
  1018.  *        the number of bits to be  checked  in  each  bit  mask  that
  1019.  *        represent  a file descriptor; the descriptors from 0 through
  1020.  *        width-1 in the  descriptor  sets  are  examined.   Typically
  1021.  *        width  has  the  value  returned by getdtablesize for the
  1022.  *        maximum number of file  descriptors.   On  return,  select
  1023.  *        replaces  the  given descriptor sets with subsets consisting
  1024.  *        of those descriptors that are ready for the requested opera-
  1025.  *        tion.  The total number of ready descriptors in all the sets
  1026.  *        is returned.
  1027.  *
  1028.  *        If timeout is not a NULL pointer,  it  specifies  a  maximum
  1029.  *        interval  to wait for the selection to complete.  If timeout
  1030.  *        is a NULL  pointer,  the  select  blocks  indefinitely.   To
  1031.  *        effect  a  poll,  the  timeout argument should be a non-NULL
  1032.  *        pointer, pointing to a zero-valued timeval structure.
  1033.  *
  1034.  *        Any of readfds, writefds, and exceptfds may be given as NULL
  1035.  *        pointers if no descriptors are of interest.
  1036.  *
  1037.  *        Using select to open a socket for reading is analogous  to
  1038.  *        performing an accept call.
  1039.  *
  1040.  *        select() returns the number of ready  descriptors  that  are
  1041.  *        contained  in  the  descriptor  sets,  or  -1  if  an  error
  1042.  *        occurred.  If the time limit expires then  select()  returns
  1043.  *        0.   If select() returns with an error the descriptor sets 
  1044.  *      will be unmodified.
  1045.  */
  1046. int s_select(
  1047.     Int4 width,
  1048.     fd_set *readfds,
  1049.     fd_set *writefds,
  1050.     fd_set *exceptfds,
  1051.     struct timeval *timeout)
  1052. {
  1053.     SocketPtr sp;
  1054.     long count;
  1055.     int s;
  1056.     long starttime, waittime;
  1057.     fd_set rd, wd, ed;
  1058.     int errorHappened;
  1059.  
  1060. #if SOCK_DEBUG >= 4
  1061.     dprintf("select:  socket: width %d\n",width);
  1062. #endif
  1063.     if (!goodptr(timeout) && timeout != NULL)
  1064.         return(sock_err(EFAULT));
  1065.     if (!goodptr(readfds) && readfds != NULL)
  1066.         return(sock_err(EFAULT));
  1067.     if (!goodptr(writefds) && writefds != NULL)
  1068.         return(sock_err(EFAULT));
  1069.     if (!goodptr(exceptfds) && exceptfds != NULL)
  1070.         return(sock_err(EFAULT));
  1071.         
  1072. #if SOCK_DEBUG >= 4
  1073.     dprintf("select: timeout %d sec, read %08x write %08x except %08x\n",
  1074.         (timeout ? timeout->tv_sec : 99999), 
  1075.         (readfds!=NULL ? *readfds : 0L),
  1076.         (writefds!=NULL ? *writefds : 0L),
  1077.         (exceptfds!=NULL ? *exceptfds : 0L));
  1078. #endif
  1079.  
  1080.     if (width > NUM_SOCKETS)    /* for now..xxx. */
  1081.         width = NUM_SOCKETS;
  1082.     count = 0;
  1083.     FD_ZERO(&rd);
  1084.     FD_ZERO(&wd);
  1085.     FD_ZERO(&ed);
  1086.  
  1087.     if (timeout) 
  1088.     {
  1089.         waittime = TVTOTICK(timeout->tv_sec,timeout->tv_usec);
  1090.         starttime = TickCount();
  1091.     }
  1092. #if SOCK_DEBUG >= 5
  1093.     dprintf("     starttime = %d(tics);  waittime = %d\n",starttime, waittime);
  1094. #endif
  1095.  
  1096.     do 
  1097.     {
  1098.         for (s = 0 , sp = sockets ; s < width ; ++s, ++sp) 
  1099.         {
  1100.             if (is_used(sp)) 
  1101.             {
  1102.                 errorHappened = 0;
  1103.                 
  1104.                 /* Check if there is data or connection available. */
  1105.                 if (readfds && FD_ISSET(s,readfds)) 
  1106.                 {
  1107.                         
  1108.                     switch(sp->protocol) 
  1109.                     {
  1110.                         case IPPROTO_UDP:
  1111.                             switch (sock_udp_can_recv(sp))
  1112.                             {
  1113.                                 case 1:
  1114.                                     FD_SET(s,&rd);
  1115.                                     ++count;
  1116.                                     break;
  1117.                                 case -1:
  1118.                                     errorHappened = 1;
  1119.                                     break;
  1120.                             }
  1121.                             break;
  1122.                 
  1123.                         case IPPROTO_TCP:
  1124.                     /* Must exit if stream is dead to avoid eternal lock up */
  1125.                             if (sock_tcp_can_read(sp) ) {
  1126.                                 FD_SET(s,&rd);
  1127.                                 ++count;
  1128.                                 } 
  1129.                             break;
  1130.                     }
  1131.                 }
  1132.                 if (writefds && FD_ISSET(s,writefds)) 
  1133.                 {
  1134.                     switch(sp->protocol) 
  1135.                     {
  1136.                         case IPPROTO_UDP:
  1137.                             switch (sock_udp_can_send(sp))
  1138.                             {
  1139.                                 case 1:
  1140.                                     FD_SET(s,&wd);
  1141.                                     ++count;
  1142.                                     break;
  1143.                                 case -1:
  1144.                                     errorHappened = 1;
  1145.                                     break;
  1146.                             }
  1147.                             break;
  1148.                 
  1149.                         case IPPROTO_TCP:
  1150.                             if (sock_tcp_can_write(sp))
  1151.                             {
  1152.                                 FD_SET(s,&wd);
  1153.                                 ++count;
  1154.                             }
  1155.                             break;
  1156.                     }
  1157.                 }
  1158.                 if (exceptfds && FD_ISSET(s,exceptfds)) 
  1159.                 {
  1160.                     if (errorHappened)  
  1161.                     {
  1162.                         FD_SET(s,&ed);
  1163.                         ++count;
  1164.                     }
  1165.                 }
  1166.             }
  1167.         }
  1168.         SPIN(false,SP_SELECT,0)
  1169.     } 
  1170.     while(count == 0 &&(timeout == 0 || TickCount() - starttime < waittime));
  1171.  
  1172.     if (readfds)             
  1173.         *readfds = rd;
  1174.     if (writefds)             
  1175.         *writefds = wd;
  1176.     if (exceptfds)             
  1177.         *exceptfds = ed;
  1178. #if SOCK_DEBUG >= 5
  1179.     dprintf("     elapsed = %d(tics)  count %d, read %08x write %08x except %08x\n",
  1180.         TickCount()-starttime,count,
  1181.         (readfds!=NULL ? *readfds : 0L),
  1182.         (writefds!=NULL ? *writefds : 0L),
  1183.         (exceptfds!=NULL ? *exceptfds : 0L));
  1184. #endif
  1185.     return(count);
  1186. }
  1187.     
  1188. /*
  1189.  *    s_getdtablesize()
  1190.  *
  1191.  *        The entries in the socket descriptor table are numbered with small
  1192.  *        integers starting at 0. getdtablesize returns the size of the 
  1193.  *        descriptor table.
  1194.  */
  1195. int s_getdtablesize()
  1196. {
  1197.     return(NUM_SOCKETS);
  1198. }
  1199.  
  1200. /*
  1201.  *    s_getsockname(s, name, namelen)
  1202.  *
  1203.  *        getsockname returns the current name for the  socket s.
  1204.  *        Namelen should  be initialized to
  1205.  *        indicate the amount of space pointed to by name.  On  return
  1206.  *        it contains the actual size of the name returned (in bytes).
  1207.  *        
  1208.  *        A 0 is returned if the call succeeds, -1 if it fails.
  1209.  */
  1210.  
  1211. int s_getsockname(
  1212.     Int4 s,
  1213.     struct sockaddr *name,
  1214.     Int4 *namelen)
  1215. {
  1216. #if SOCK_DEBUG >= 3
  1217.     dprintf("GETSOCKNAME: %d\n", s);
  1218. #endif
  1219.     if (! sock_good_fd(s))
  1220.         return(sock_err(EBADF));
  1221.  
  1222.     if (! goodptr(name))
  1223.         return(sock_err(EFAULT));
  1224.         
  1225.     if (*namelen < 0)
  1226.         return(sock_err(EINVAL));
  1227.  
  1228.     sock_copy_addr(&sockets[s].sa, name, namelen);
  1229.     return(0);
  1230. }
  1231.  
  1232. /*
  1233.  *    s_getpeername(s, name, namelen)
  1234.  *
  1235.  *        getpeername returns the name of the peer connected to socket s.
  1236.  *
  1237.  *        The  int  pointed  to  by the namelen parameter
  1238.  *        should be  initialized  to  indicate  the  amount  of  space
  1239.  *        pointed  to  by name.  On return it contains the actual size
  1240.  *        of the name returned (in bytes).  The name is  truncated  if
  1241.  *        the buffer provided is too small.
  1242.  *        
  1243.  *        A 0 is returned if the call succeeds, -1 if it fails.
  1244.  */
  1245. int s_getpeername(
  1246.     Int4 s,
  1247.     struct sockaddr *name,
  1248.     Int4 *namelen)
  1249. {
  1250.     SocketPtr sp;
  1251.  
  1252. #if SOCK_DEBUG >= 2
  1253.     dprintf("getpeername: socket %d\n", s);
  1254. #endif
  1255.     if (! sock_good_fd(s))
  1256.         return(sock_err(EBADF));        
  1257.  
  1258.     sp = sockets+s;
  1259.     if (! is_used (sp))
  1260.         return (sock_err (EBADF));
  1261.  
  1262.     if (! goodptr(name))
  1263.         return(sock_err(EFAULT));
  1264.         
  1265.     if (*namelen < 0)
  1266.         return(sock_err(EINVAL));
  1267.  
  1268.     if (sp->sstate != SOCK_STATE_CONNECTED) 
  1269.         return(sock_err(ENOTCONN));
  1270.  
  1271.     sock_copy_addr(&sockets[s].peer, name, namelen);
  1272.  
  1273.     return(0);
  1274. }
  1275.  
  1276. /*
  1277.  *    s_shutdown(s, how)
  1278.  *
  1279.  *        shutdown call causes all or part of a full-duplex
  1280.  *        connection on the socket s to be shut down.  If
  1281.  *        how is 0, then further receives will be disallowed.  If  how
  1282.  *        is  1,  then further sends will be disallowed.  If how is 2,
  1283.  *        then further sends and receives will be disallowed.
  1284.  *        
  1285.  *        A 0 is returned if the call succeeds, -1 if it fails.
  1286.  */
  1287. int s_shutdown(
  1288.     Int4 s,
  1289.     Int4 how)
  1290. {
  1291.     SocketPtr sp;
  1292.     
  1293. #if SOCK_DEBUG >= 2
  1294.     dprintf("shutdown: shutdown %d\n", s);
  1295. #endif
  1296.     if (! sock_good_fd(s))
  1297.         return(sock_err(EBADF));
  1298.     sp = sockets+s;
  1299.  
  1300.     switch(how) 
  1301.     {
  1302.         case 0 : 
  1303.             sp->status |= SOCK_STATUS_NOREAD;
  1304.             break;
  1305.             
  1306.         case 1 : 
  1307.             sp->status |= SOCK_STATUS_NOWRITE;
  1308.             break;
  1309.  
  1310.         case 2 :
  1311.             sp->status |= SOCK_STATUS_NOREAD | SOCK_STATUS_NOWRITE;
  1312.             break;
  1313.             
  1314.         default :
  1315.             return(sock_err(EINVAL));
  1316.     }
  1317.     return(0);
  1318. }
  1319.  
  1320. /*
  1321.  *    fcntl() operates on the socket s according to the order in cmd:
  1322.  *
  1323.  *        F_DUPFD    Like Dup. Returns a new descriptor which refers to the 
  1324.  *                same MacTCP stream as s and has the same descriptor 
  1325.  *                status.
  1326.  *
  1327.  *        F_GETFL    returns the descriptor status flags for s. The only
  1328.  *                flag supported is FNDELAY for non-blocking i/o.
  1329.  *
  1330.  *        F_SETFL    sets descriptor status flags for s. The only
  1331.  *                 flag supported is FNDELAY for non-blocking i/o.
  1332.  *
  1333.  *        A dup or F_DUPFD operation copies the descriptor status flags
  1334.  *        maintained by F_SETFL, but once the copy is done, the two are
  1335.  *        disjoint. THIS IS DIFFERENT FROM UNIX.
  1336.  *
  1337.  *        Upon successful completion, the value  returned  depends  on
  1338.  *        cmd as follows:
  1339.  *            F_DUPFD   A new descriptor.
  1340.  *             F_GETFL   Value of flags.
  1341.  *            F_SETFL   0.
  1342.  *
  1343.  *        On error, a value of -1  is returned and errno is set to indicate 
  1344.  *        the error.
  1345.  *
  1346.  *        EBADF           s is not a valid open descriptor.
  1347.  *
  1348.  *        EMFILE          cmd is F_DUPFD and socket descriptor table is full.
  1349.  *
  1350.  *        EINVAL          cmd is F_DUPFD and arg  is  negative  or
  1351.  *                      greater   than   the  maximum  allowable
  1352.  *                      number (see getdtablesize).
  1353.  */
  1354. int s_fcntl(
  1355.     Int4 s,
  1356.     unsigned Int4 cmd,
  1357.     Int4 arg)
  1358. {
  1359. #if SOCK_DEBUG >= 2
  1360.     dprintf("s_fcntl: %d\n", s);
  1361. #endif
  1362.  
  1363.     if (! sock_good_fd(s))
  1364.         return(sock_err(EBADF));
  1365.  
  1366.     switch(cmd) 
  1367.     {
  1368.         /*
  1369.          * Duplicate a socket.
  1370.          */
  1371.         case F_DUPFD : 
  1372.         {
  1373.             int s1;
  1374.             
  1375.             if (arg < 0 || arg >= NUM_SOCKETS)
  1376.                 return(sock_err(EINVAL));
  1377.             
  1378.             s1 = sock_free_fd(arg);
  1379.             if (s1 == -1)
  1380.                 return(sock_err(EMFILE));
  1381.             
  1382.             sock_dup_fd(s,s1);
  1383.             return(s1);
  1384.         }
  1385.         
  1386.         /*
  1387.          *  Get socket status.  This is like getsockopt().
  1388.          *  Only supported descriptor status is FNDELAY.
  1389.          */
  1390.         case F_GETFL : 
  1391.         {
  1392.             SocketPtr sp;
  1393.     
  1394.             sp = sockets+s;
  1395.             if (sp->nonblocking)
  1396.                 return(FNDELAY);
  1397.             else
  1398.                 return(0);
  1399.         }
  1400.         
  1401.         /*
  1402.          *  Set socket status.  This is like setsockopt().
  1403.          *  Only supported descriptor status is FNDELAY.
  1404.          */
  1405.         case F_SETFL : 
  1406.         {
  1407.             SocketPtr sp;
  1408.     
  1409.             sp = sockets+s;
  1410.             if (arg & FNDELAY)
  1411.                 sp->nonblocking = true;
  1412.             else
  1413.                 sp->nonblocking = false;
  1414.             
  1415.             return(0);
  1416.         }
  1417.     }
  1418. }
  1419.  
  1420. /*
  1421.  *    dup(s)
  1422.  *
  1423.  *    dup2(s, news)
  1424.  *
  1425.  *        dup() duplicates an existing socket descriptor.   The  argu-
  1426.  *        ment s is a small non-negative integer index in the per-
  1427.  *        process descriptor table.  The value must be less  than  the
  1428.  *        size  of  the  table, which is returned by getdtablesize(2).
  1429.  *        The new descriptor returned by the call is the  lowest  num-
  1430.  *        bered  descriptor  that  is not currently in use by the pro-
  1431.  *        cess.
  1432.  *
  1433.  *        In the second form  of  the  call,  the  value  of  the  new
  1434.  *        descriptor  desired  is  specified.   If  that descriptor is
  1435.  *        already in use, the descriptor is first deallocated as if  a
  1436.  *        close(2) call had been done first.
  1437.  *
  1438.  *        The value -1 is returned if an error occurs in either  call.
  1439.  *        The  external  variable  errno  indicates  the  cause of the
  1440.  *        error.
  1441.  *
  1442.  *        EBADF               s or  news is  not  a  valid  socket
  1443.  *                            descriptor.
  1444.  *
  1445.  *        EMFILE              Too many descriptors are active.
  1446.  */
  1447. int s_dup(
  1448.     Int4 s)
  1449. {
  1450.     return(s_fcntl(s, F_DUPFD, 0));
  1451. }
  1452.  
  1453. int s_dup2(
  1454.     Int4 s,
  1455.     Int4 s1)
  1456. {
  1457.     if (! sock_good_fd(s))
  1458.         return(sock_err(EBADF));
  1459.  
  1460.     if (s1 < 0 || s1 >= NUM_SOCKETS)
  1461.         return(sock_err(EBADF));
  1462.  
  1463.     if (is_used(sockets+s1))
  1464.     {
  1465.         if (s_close(s1) == -1)
  1466.             return(-1);
  1467.     }
  1468.     sock_dup_fd(s,s1);
  1469.     return(s1);
  1470. }
  1471.  
  1472.  
  1473. /*
  1474.  * s_Ioctl()
  1475.  */
  1476. int s_ioctl(
  1477.     Int4 d,
  1478.     Int4 request,
  1479.     Int4 *argp)
  1480. {
  1481.     struct    ifreq    *ifr;
  1482.     TCPiopb        *tpb;
  1483.     SocketPtr    sp;
  1484.     int            size;
  1485.  
  1486. #if SOCK_DEBUG >= 2
  1487.     dprintf("s_ioctl: %d, request %d\n", d,request);
  1488. #endif
  1489.  
  1490.     if (! sock_good_fd(d))
  1491.         return(sock_err(EBADF));
  1492.  
  1493.     sp = sockets+d;
  1494.     
  1495.     /*
  1496.      * Interpret high order word to find amount of data to be copied 
  1497.      * to/from the user's address space.
  1498.      */
  1499.     size =(request &~(IOC_INOUT | IOC_VOID)) >> 16;
  1500.     
  1501.     /*
  1502.      * Zero the buffer on the stack so the user gets back something deterministic.
  1503.      */
  1504.     if ((request & IOC_OUT) && size)
  1505.         bzero((void *)argp, size);
  1506.  
  1507.     ifr =(struct ifreq *)argp;
  1508.     switch(request) 
  1509.     {
  1510.         /* Non-blocking I/O */
  1511.         case FIONBIO:
  1512.             sp->nonblocking = *(Boolean *)argp;
  1513.             return(0);
  1514.  
  1515.          /* Number of bytes on input Q */
  1516.         case FIONREAD:
  1517.             tpb = sock_fetch_pb(sp);
  1518.             sp->dataavail = xTCPBytesUnread(sp);
  1519.             *(int *)argp=sp->dataavail;
  1520.             return 0;
  1521.  
  1522. #ifdef IOCTL_LATER    
  1523.         /*
  1524.          *    Get interface list.  Pass in buffer and buffer length.
  1525.          *    Returns list of length one of ifreq's 
  1526.          */
  1527.         case SIOCGIFCONF: 
  1528.         {    
  1529.             struct ifconf *ifc =(struct ifconf *)argp;
  1530.             struct ifreq *req = ifc->ifc_req;
  1531.             int reqlen;
  1532.             struct sockaddr_in *addr;
  1533.             
  1534.             /*
  1535.              *    Fill in req fields for the IF's name and local IP addr.
  1536.              */
  1537.             strncpy(req->ifr_name, myIFName, IFNAMSIZ);
  1538.             addr =(struct sockaddr_in *)&req->ifr_addr;
  1539.             addr->sin_family         = AF_INET;
  1540.             addr->sin_addr.s_addr    = myIPAddress;
  1541.             addr->sin_port            = 0;
  1542.             bzero(addr->sin_zero, sizeof(addr->sin_zero));
  1543.             ifc->ifc_len = sizeof(*req);
  1544.                     
  1545.             return(0);            
  1546.         }
  1547.  
  1548.         /*
  1549.          *    Returns MTU of specified IF.
  1550.          */
  1551.         case SIOCGIFMTU: 
  1552.         {    
  1553.             /* don't check IF specification - we only have one anyway */
  1554.             *(int *)ifr->ifr_data= xMaxMTU();
  1555.             return(0);
  1556.         }
  1557.         
  1558.         /*
  1559.          *    Returns local IP Address of IF
  1560.          */
  1561.         case SIOCGIFADDR: 
  1562.         {
  1563.             struct sockaddr_in *addr;
  1564.             
  1565.             /* don't check IF specification - we only have one anyway */
  1566.  
  1567.             addr = &ifr->ifr_addr;
  1568.             addr->sin_addr.s_addr = xIPAddr();
  1569.             addr->sin_family = AF_INET;
  1570.             return(0);
  1571.         }
  1572.  
  1573.         case SIOCGIFDSTADDR:         /* For point to point, which we don't support */
  1574.             return(sock_err(EINVAL));
  1575.  
  1576.         case SIOCGIFFLAGS:             /* Returns IF flags(none yet) */
  1577.             ifr->ifr_flags = 0;
  1578.             return(0);
  1579.             
  1580.         /*
  1581.          *    Return broadcast address - net address plus all ones in host part
  1582.          */
  1583.         case SIOCGIFBRDADDR:     
  1584.         {
  1585.             struct sockaddr_in *addr;
  1586.             
  1587.             /* don't check IF specification */
  1588.             /* we only have one and its broadcast  */
  1589.                 
  1590.             addr = &ifr->ifr_addr;
  1591.             addr->sin_addr.s_addr = xIPAddr() | ~xNetMask();
  1592.             return(0);
  1593.         }
  1594. #endif IOCTL_LATER    
  1595.         default :
  1596.             return(sock_err(EOPNOTSUPP));
  1597.     }
  1598. }
  1599.  
  1600. /*
  1601.  *    s_setsockopt()
  1602.  *
  1603.  *        Set socket options. None implemented. In Unix there are...
  1604.  *
  1605.  *          SO_REUSEADDR        toggle local address reuse
  1606.  *          SO_KEEPALIVE        toggle keep connections alive
  1607.  *          SO_DONTROUTE        toggle routing bypass for  outgoing
  1608.  *                              messages
  1609.  *          SO_LINGER           linger on close if data present
  1610.  *          SO_BROADCAST        toggle   permission   to   transmit
  1611.  *                              broadcast messages
  1612.  *          SO_OOBINLINE        toggle  reception  of   out-of-band
  1613.  *                              data in band
  1614.  *          SO_SNDBUF           set buffer size for output
  1615.  *          SO_RCVBUF           set buffer size for input
  1616.  *          SO_TYPE             get the type  of  the  socket  (get
  1617.  *                              only)
  1618.  *          SO_ERROR            get and clear error on  the  socket
  1619.  *                             (get only)
  1620.  */
  1621. int s_setsockopt(
  1622.     Int4 s,
  1623.     Int4 level,
  1624.     Int4 optname,
  1625.     char *optval,
  1626.     Int4 optlen)
  1627. {
  1628. #pragma unused(optval)
  1629. #pragma unused(optlen)
  1630.     SocketPtr sp;
  1631.  
  1632. #if SOCK_DEBUG >= 3
  1633.     dprintf("SETSOCKOPT:  socket: %d  option: %d  \n", s,optname);
  1634. #endif
  1635.     if (! sock_good_fd(s))
  1636.         return(sock_err(EBADF));
  1637.  
  1638.     sp = sockets+s;
  1639.  
  1640.     /*
  1641.      * demultiplex to socket option handlers at other protocol levels.(None
  1642.      * supported yet).
  1643.      */
  1644.     switch(level) 
  1645.     {
  1646.         case SOL_SOCKET :         /* socket level option */
  1647.             switch(optname) 
  1648.             {
  1649.                 default :
  1650.                     return(0);
  1651.             }
  1652.             break;
  1653.         case IPPROTO_TCP:
  1654.             switch(optname)
  1655.             {
  1656.                 default:
  1657.                     return(0);
  1658.             }
  1659.             break;
  1660.         default :
  1661.             return(sock_err(ENOPROTOOPT));
  1662.     }
  1663.     return(0);
  1664. }
  1665.  
  1666.  
  1667. /*
  1668.  * s_setspin() - define a routine to be called repeatedly when
  1669.  *                 socket routines are blocked (ie. spinning)
  1670.  *
  1671.  *                 pass a NULL pointer to turn off a previously
  1672.  *                 defined spin routine.
  1673.  */
  1674. int s_setspin(
  1675.     SpinFn routine)
  1676. {
  1677.     if (routine == NULL || goodptr(routine))
  1678.         {
  1679.         spinroutine = routine;
  1680.         return(0);
  1681.         }
  1682.     else
  1683.         return(sock_err(EFAULT));
  1684. }
  1685.  
  1686. /*
  1687.  * s_getspin() - returns current spinroutine
  1688.  */
  1689. SpinFn s_getspin()
  1690.     {
  1691.     return (spinroutine);
  1692.     }
  1693.     
  1694. int defaultSpin(spin_msg msg,long param)
  1695.     {
  1696. #pragma unused (msg,param)
  1697.     EventRecord evrec;
  1698.     
  1699.     WaitNextEvent(0, &evrec, 1 /* ticks */, NULL);
  1700.     return 0;        /* return non-zero to exit current routine */
  1701.     }
  1702.